feat(universal-cookie): basic implementation of universal cookie - #404

/*
same as example
*/

export default function (params: aspnet.BootFuncParams): Promise<{ html: string, globals?: any }> {
  let cookie = new ngUniversal.Cookie(); // create universal cookie implementation
  magicParseFunction(params.cookie).map((key, value) => cookie.set(key, value));// set cookie with some cookie contract object that need to parsed from pure aspnet cookie string

  const serverBindings = [
    ngCore.provide(BASE_URL, { useValue: '/' }),
    ngCore.provide(ORIGIN_URL, { useValue: params.origin }),
    ngCore.provide(REQUEST_URL, { useValue: params.url }),
    ngCore.provide(REQUEST_COOKIE, { useValue: cookie }), // provide cookie to ng2-universal
    ...ngUniversal.NODE_PLATFORM_PIPES,
    ...ngUniversal.NODE_ROUTER_PROVIDERS,
    ...ngUniversal.NODE_HTTP_PROVIDERS,
  ];
/*
same as example
*/

// Angular 2 Universal
import {
  REQUEST_URL,
  ORIGIN_URL,
  Cookie,
  CookieAttributes,
  COOKIE_KEY,
  NODE_LOCATION_PROVIDERS,
  NODE_HTTP_PROVIDERS,
  ExpressEngineConfig,
} from 'angular2-universal';

import {Injectable} from "@angular/core";
import { APP_BASE_HREF} from '@angular/common';

// Application
import {ElaraApp} from './app/app';
import {appRouterProviders} from './app/routes/app.routes';
import {SessionService, ServerSessionService} from './app/services/sessions.service';
import {WindowService} from './app/services/window.service';
import {AppsService} from './app/services/apps.service';
import {AuthService} from './app/services/auth.service';
import {UserService} from './app/services/user.service';
import {AuthServerService} from './app/services/authServer.service';
import {RedirectService, RedirectServerService} from './app/services/redirect.service';
import {AuthGuard} from './app/services/guard/auth-guard.service';
import {NotificationService} from './app/services/notification.service';
import {ModalService} from './app/services/modal.service';
import {ExtendedInfoService} from './app/services/extended-info.service';

@Injectable()
class BasicCookie implements Cookie {
  constructor(private headers: any){
  }
  set(key: string, value: string, attributes?: CookieAttributes): void{
    this.headers[key] = value;
  }
  get(key?: string): string {
    if(this.headers[key]){
      return key + '=' + this.headers[key];
    }
    return "";  
  }
  remove(key: string, attributes?: CookieAttributes): any{
    return false;
  }
  toJSON(): Object{
    return JSON.stringify(this.headers);
  }
}

export function ngApp(req, res) {
  let baseUrl = '/';
  let url = req.originalUrl || '/';
  let originUrl = process.env.WEB_URL || 'http://locahost:5000';
  let cookie = new BasicCookie(req.cookies);
  if(req.query.jwt) {
    cookie.set("my_session", req.query.jwt);
    let now = new Date(Date.now());
    res.cookie("my_session", req.query.jwt, {expires: new Date(now.setHours(now.getHours() + 1)), httpOnly: false});
  }

  if(cookie.get('my_session')){
      let config: ExpressEngineConfig = {
          directives: [
            MyApp
          ],
          platformProviders: [
            {provide: ORIGIN_URL, useValue: originUrl},
            {provide: APP_BASE_HREF, useValue: baseUrl},
            {provide: COOKIE_KEY, useValue: 'my_session'}
          ],
          providers: [
            NODE_HTTP_PROVIDERS,
            appRouterProviders,
            NODE_LOCATION_PROVIDERS,
            {provide: Cookie, useValue: cookie},
            AppsService,
            WindowService,
            NotificationService,
            ExtendedInfoService,
            {provide: SessionService, useClass: ServerSessionService},
            AuthGuard,
            UserService,
            ModalService,
            {provide: AuthService, useClass: AuthServerService},
            {provide: RedirectService, useClass: RedirectServerService},
            {provide: REQUEST_URL, useValue: url},
          ],
          async: true,
          preboot: false // { appRoot: 'app' } // your top level app component selector
      };

    return res.render('index', config);  
  }

  return res.redirect('https://portal.my.io?redirect=https://' + req.get('Host') + req.originalUrl)

}

if (cookieValue && !req.headers.get('Cookie')) {
   req.headers.append('Cookie', cookieValue);
 }

@Injectable()
export class NodeBackend implements ConnectionBackend {
  constructor(
    private _baseResponseOptions: ResponseOptions,
    private _ngZone: NgZone,
    @Inject(BASE_URL) private _baseUrl: string,
    @Inject(ORIGIN_URL) private _originUrl: string,
    @Inject(Cookie) private _cookie: Cookie,
    @Inject(COOKIE_KEY) private _cookieKey: Object) {}

  public createConnection(request: Request): NodeConnection {
    return new NodeConnection(request, this._baseResponseOptions, this._ngZone, this._baseUrl, this._originUrl, this._cookie, this._cookieKey);
  }
}